Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
50.00% covered (danger)
50.00%
2 / 4
 CRAP
53.06% covered (warning)
53.06%
26 / 49
EntityWithValuesUpdater
0.00% covered (danger)
0.00%
0 / 1
50.00% covered (danger)
50.00%
2 / 4
 77.71
53.06% covered (warning)
53.06%
26 / 49
 __construct
100.00% covered (success)
100.00%
1 / 1
 1
100.00% covered (success)
100.00%
2 / 2
 update
0.00% covered (danger)
0.00%
0 / 1
 2.31
57.14% covered (warning)
57.14%
4 / 7
 updateEntityWithValues
100.00% covered (success)
100.00%
1 / 1
 7
100.00% covered (success)
100.00%
8 / 8
 checkValuesData
0.00% covered (danger)
0.00%
0 / 1
 54.26
37.50% covered (danger)
37.50%
12 / 32
<?php
namespace Akeneo\Pim\Enrichment\Component\Product\Updater;
use Akeneo\Pim\Enrichment\Component\Product\Model\EntityWithValuesInterface;
use Akeneo\Tool\Component\StorageUtils\Exception\InvalidObjectException;
use Akeneo\Tool\Component\StorageUtils\Exception\InvalidPropertyTypeException;
use Akeneo\Tool\Component\StorageUtils\Updater\ObjectUpdaterInterface;
use Akeneo\Tool\Component\StorageUtils\Updater\PropertySetterInterface;
use Doctrine\Common\Util\ClassUtils;
/**
 * Update values of an entity with values.
 *
 * Note that this updater acts simply by putting values into the entity, whatever
 * theses values should be in this entity or not.
 *
 * @author    Adrien Pétremann <adrien.petremann@akeneo.com>
 * @copyright 2017 Akeneo SAS (http://www.akeneo.com)
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 */
class EntityWithValuesUpdater implements ObjectUpdaterInterface
{
    /** @var PropertySetterInterface */
    protected $propertySetter;
    /**
     * @param PropertySetterInterface $propertySetter
     */
    public function __construct(PropertySetterInterface $propertySetter)
    {
        $this->propertySetter = $propertySetter;
    }
    /**
     * {@inheritdoc}
     */
    public function update($entityWithValues, array $values, array $options = [])
    {
        if (!$entityWithValues instanceof EntityWithValuesInterface) {
            throw InvalidObjectException::objectExpected(
                ClassUtils::getClass($entityWithValues),
                EntityWithValuesInterface::class
            );
        }
        $this->checkValuesData($values);
        $this->updateEntityWithValues($entityWithValues, $values);
        return $this;
    }
    /**
     * Update values of an entity with values
     *
     * @param EntityWithValuesInterface $entityWithValues
     * @param array                     $values
     */
    protected function updateEntityWithValues(EntityWithValuesInterface $entityWithValues, array $values)
    {
        foreach ($values as $code => $value) {
            foreach ($value as $data) {
                $hasValue = $entityWithValues->getValue($code, $data['locale'], $data['scope']);
                $providedData = !('' === $data['data'] || [] === $data['data'] || null === $data['data']);
                if ($providedData || $hasValue) {
                    $options = ['locale' => $data['locale'], 'scope' => $data['scope']];
                    $this->propertySetter->setData($entityWithValues, $code, $data['data'], $options);
                }
            }
        }
    }
    /**
     * Check the structure of the given entity with values.
     *
     * @param mixed $entityWithValues
     *
     * @throws InvalidPropertyTypeException
     */
    protected function checkValuesData($entityWithValues)
    {
        if (!is_array($entityWithValues)) {
            throw InvalidPropertyTypeException::arrayExpected('values', static::class, $entityWithValues);
        }
        foreach ($entityWithValues as $code => $values) {
            if (!is_array($values)) {
                throw InvalidPropertyTypeException::arrayExpected($code, static::class, $values);
            }
            foreach ($values as $value) {
                if (!is_array($value)) {
                    throw InvalidPropertyTypeException::validArrayStructureExpected(
                        $code,
                        'one of the values is not an array.',
                        static::class,
                        $values
                    );
                }
                if (!array_key_exists('locale', $value)) {
                    throw InvalidPropertyTypeException::arrayKeyExpected($code, 'locale', static::class, $value);
                }
                if (!array_key_exists('scope', $value)) {
                    throw InvalidPropertyTypeException::arrayKeyExpected($code, 'scope', static::class, $value);
                }
                if (!array_key_exists('data', $value)) {
                    throw InvalidPropertyTypeException::arrayKeyExpected($code, 'data', static::class, $value);
                }
                if (null !== $value['locale'] && !is_string($value['locale'])) {
                    $message = 'Property "%s" expects a value with a string as locale, "%s" given.';
                    throw new InvalidPropertyTypeException(
                        $code,
                        $value['locale'],
                        static::class,
                        sprintf($message, $code, gettype($value['locale'])),
                        InvalidPropertyTypeException::STRING_EXPECTED_CODE
                    );
                }
                if (null !== $value['scope'] && !is_string($value['scope'])) {
                    $message = 'Property "%s" expects a value with a string as scope, "%s" given.';
                    throw new InvalidPropertyTypeException(
                        $code,
                        $value['scope'],
                        static::class,
                        sprintf($message, $code, gettype($value['scope'])),
                        InvalidPropertyTypeException::STRING_EXPECTED_CODE
                    );
                }
            }
        }
    }
}